package com.hibase.core.mybatis.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.github.pagehelper.PageInfo;
import com.hibase.common.entity.PageBase;
import com.hibase.core.mybatis.registrar.HibaseMapper;

import java.io.Serializable;
import java.util.Collection;
import java.util.Map;

/**
 * 父类service接口
 *
 * @author hufeng
 * @date 2019/03/21
 */
public interface BaseService<T> extends IService<T> {

    HibaseMapper<T> getBaseMapper();
    /**
     * 通用保存
     *
     * @param entity
     * @return
     */
    T store(T entity);

    /**
     * 批量保存
     *
     * @param entityList
     * @param batchSize  批量大小
     * @return
     */
    boolean storeBatch(Collection<T> entityList, int batchSize);

    /**
     * 批量保存
     *
     * @param entityList
     * @param throwException 空集合是否抛出异常
     * @return
     */
    boolean storeBatch(Collection<T> entityList, boolean throwException);

    /**
     * 批量保存
     *
     * @param entityList
     * @return
     */
    boolean storeBatch(Collection<T> entityList);

    /**
     * pagehelper分页
     *
     * @param pageBase
     * @param queryWrapper
     * @return
     */
    PageInfo<T> page(PageBase pageBase, Wrapper<T> queryWrapper);

    /**
     * 通过id获取记录
     *
     * @param id
     * @param throwException true 为空抛出异常，false 返回null
     * @return
     */
    T getById(Serializable id, boolean throwException);

    /**
     * 根据条件id删除
     * @param id
     * @param beLogic true 逻辑删除
     * @return
     */
    default boolean deleteBy(String id,boolean beLogic) {
        if(beLogic){
            return SqlHelper.retBool(this.getBaseMapper().removeById(id));
        }
        else {
            return this.removeById(id);
        }
    }

    /**
     * 根据条件id物理删除
     *
     * @param id
     * @return
     */
    boolean deleteBy(String id);

    /**
     * 根据条件物理删除
     *
     * @param queryWrapper 查询参数
     * @return
     */
    default boolean deleteBy(Wrapper<T> queryWrapper,boolean beLogic) {
        if(beLogic){
            return SqlHelper.retBool(this.getBaseMapper().remove(queryWrapper));
        }
        else {
            return this.remove(queryWrapper);
        }
    }

    /**
     * 根据@Override
	条件物理删除
     *
     * @param queryWrapper 查询参数
     * @return
     */
    boolean deleteBy(Wrapper<T> queryWrapper);

    /**
     * 根据条件id集合物理删除
     *
     * @param ids
     * @param throwException 是否开启校验，校验不通过抛出异常
     * @return
     */
    boolean deleteBy(Collection<? extends Serializable> ids, boolean throwException);

    /**
     * 物理批量删除，未开启校验，不抛出异常
     *
     * @param ids
     * @return
     */
    boolean deleteBy(Collection<? extends Serializable> ids);

    /**
     * 根据对象物理删除
     *
     * @param object
     * @return
     */
    boolean deleteBy(T object);

    PageInfo<Map<String, Object>> pageMaps(PageBase pageBase, Wrapper<T> queryWrapper);

    default boolean updateNullById(T entity) {
        return SqlHelper.retBool(this.getBaseMapper().updateNullById(entity));
    }

    default boolean updateNull(T entity,Wrapper<T> updateWrapper) {
        return SqlHelper.retBool(this.getBaseMapper().updateNull(entity,updateWrapper));
    }

}
